package org.alwayssuper.protocol.commons.transform.realtimev2025;

import org.alwayssuper.protostar.annotation.Field;
import lombok.Data;
import lombok.ToString;
import lombok.experimental.Accessors;

/**
 * 2025版超级电容器极值数据格式 (0x32)
 * 参考GB/T 32960.3-2025标准表26
 * @author alwaysSuper
 */
@ToString
@Data
@Accessors(chain = true)
public class SupercapacitorExtremeData {
    @Field(length = 1, desc = "最高电压管理系统号:有效值范围1~253")
    private int maxVoltageSystemNo;
    
    @Field(length = 2, desc = "最高电压超级电容单体代号:有效值范围1~65531")
    private int maxVoltageCellNo;
    
    @Field(length = 2, desc = "超级电容单体电压最高值:有效值范围0~60000(表示0V~60.000V),精度0.001V")
    private int maxVoltageValue;
    
    @Field(length = 1, desc = "最低电压管理系统号:有效值范围1~253")
    private int minVoltageSystemNo;
    
    @Field(length = 2, desc = "最低电压超级电容单体代号:有效值范围1~65531")
    private int minVoltageCellNo;
    
    @Field(length = 2, desc = "超级电容单体电压最低值:有效值范围0~60000(表示0V~60.000V),精度0.001V")
    private int minVoltageValue;
    
    @Field(length = 1, desc = "最高温度管理系统号:有效值范围1~253")
    private int maxTemperatureSystemNo;
    
    @Field(length = 2, desc = "最高温度探针代号:有效值范围1~65531")
    private int maxTemperatureProbeNo;
    
    @Field(length = 1, desc = "最高温度值:有效值范围0~250(偏移40℃,-40℃~+210℃),精度1℃")
    private int maxTemperatureValue;
    
    @Field(length = 1, desc = "最低温度管理系统号:有效值范围1~253")
    private int minTemperatureSystemNo;
    
    @Field(length = 2, desc = "最低温度探针代号:有效值范围1~65531")
    private int minTemperatureProbeNo;
    
    @Field(length = 1, desc = "最低温度值:有效值范围0~250(偏移40℃,-40℃~+210℃),精度1℃")
    private int minTemperatureValue;
    
    // ==================== 传输值与真实值转换方法 ====================
    
    /**
     * 获取最高电压值 (V)
     * @return 最高电压，精度0.001V，异常返回-1，无效返回-2
     */
    public double getMaxVoltageValue() {
        if (maxVoltageValue == 0xFFFE) return -1.0; // 异常
        if (maxVoltageValue == 0xFFFF) return -2.0; // 无效
        return maxVoltageValue * 0.001; // 传输值×0.001 = 值(V)
    }
    
    /**
     * 设置最高电压值 (V)
     * @param voltage 最高电压值，范围0~60.000V
     */
    public void setMaxVoltageValue(double voltage) {
        if (voltage < 0 || voltage > 60.0) {
            this.maxVoltageValue = 0xFFFF; // 无效值
        } else {
            this.maxVoltageValue = (int) Math.round(voltage * 1000); // 值×1000 = 传输值
        }
    }
    
    /**
     * 获取最低电压值 (V)
     * @return 最低电压，精度0.001V，异常返回-1，无效返回-2
     */
    public double getMinVoltageValue() {
        if (minVoltageValue == 0xFFFE) return -1.0; // 异常
        if (minVoltageValue == 0xFFFF) return -2.0; // 无效
        return minVoltageValue * 0.001; // 传输值×0.001 = 值(V)
    }
    
    /**
     * 设置最低电压值 (V)
     * @param voltage 最低电压值，范围0~60.000V
     */
    public void setMinVoltageValue(double voltage) {
        if (voltage < 0 || voltage > 60.0) {
            this.minVoltageValue = 0xFFFF; // 无效值
        } else {
            this.minVoltageValue = (int) Math.round(voltage * 1000); // 值×1000 = 传输值
        }
    }
    
    /**
     * 获取最高温度值 (℃)
     * @return 最高温度，精度1℃，异常返回-999，无效返回-1000
     */
    public int getMaxTemperatureValue() {
        if (maxTemperatureValue == 0xFE) return -999; // 异常
        if (maxTemperatureValue == 0xFF) return -1000; // 无效
        return maxTemperatureValue - 40; // (传输值-40) = 值(℃)，支持负值
    }
    
    /**
     * 设置最高温度值 (℃)
     * @param temperature 最高温度值，范围-40℃~+210℃
     */
    public void setMaxTemperatureValue(int temperature) {
        if (temperature < -40 || temperature > 210) {
            this.maxTemperatureValue = 0xFF; // 无效值
        } else {
            this.maxTemperatureValue = temperature + 40; // (值+40) = 传输值
        }
    }
    
    /**
     * 获取最低温度值 (℃)
     * @return 最低温度，精度1℃，异常返回-999，无效返回-1000
     */
    public int getMinTemperatureValue() {
        if (minTemperatureValue == 0xFE) return -999; // 异常
        if (minTemperatureValue == 0xFF) return -1000; // 无效
        return minTemperatureValue - 40; // (传输值-40) = 值(℃)，支持负值
    }
    
    /**
     * 设置最低温度值 (℃)
     * @param temperature 最低温度值，范围-40℃~+210℃
     */
    public void setMinTemperatureValue(int temperature) {
        if (temperature < -40 || temperature > 210) {
            this.minTemperatureValue = 0xFF; // 无效值
        } else {
            this.minTemperatureValue = temperature + 40; // (值+40) = 传输值
        }
    }
    
    /**
     * 检查最高电压值是否有效
     * @return true: 有效, false: 异常或无效
     */
    public boolean isMaxVoltageValueValid() {
        return maxVoltageValue != 0xFFFE && maxVoltageValue != 0xFFFF;
    }
    
    /**
     * 检查最低电压值是否有效
     * @return true: 有效, false: 异常或无效
     */
    public boolean isMinVoltageValueValid() {
        return minVoltageValue != 0xFFFE && minVoltageValue != 0xFFFF;
    }
    
    /**
     * 检查最高温度值是否有效
     * @return true: 有效, false: 异常或无效
     */
    public boolean isMaxTemperatureValueValid() {
        return maxTemperatureValue != 0xFE && maxTemperatureValue != 0xFF;
    }
    
    /**
     * 检查最低温度值是否有效
     * @return true: 有效, false: 异常或无效
     */
    public boolean isMinTemperatureValueValid() {
        return minTemperatureValue != 0xFE && minTemperatureValue != 0xFF;
    }
    
    /**
     * 获取电压差值 (V)
     * @return 最高电压与最低电压的差值，如果任一值无效则返回-1
     */
    public double getVoltageDifference() {
        if (!isMaxVoltageValueValid() || !isMinVoltageValueValid()) {
            return -1.0; // 无效
        }
        return getMaxVoltageValue() - getMinVoltageValue();
    }
    
    /**
     * 获取温度差值 (℃)
     * @return 最高温度与最低温度的差值，如果任一值无效则返回-1000
     */
    public int getTemperatureDifference() {
        if (!isMaxTemperatureValueValid() || !isMinTemperatureValueValid()) {
            return -1000; // 无效
        }
        return getMaxTemperatureValue() - getMinTemperatureValue();
    }
}